home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 November: Tool Chest / Dev.CD Nov 00 TC Disk 1.toast / Sample Code / Devices and Hardware / ADB / SetLED / SetLED.c next >
Encoding:
C/C++ Source or Header  |  2000-09-28  |  7.9 KB  |  233 lines  |  [TEXT/CWIE]
  1. /*
  2.     File:        SetLED.c
  3.     
  4.     Description:Sample program to demonstrate the use of the ADBOp call, including use
  5.                 of the completion routine under 68K, CFM68K, and PPC.
  6.             
  7.                 demonstrates a workaround for a bug with the CFM68K InterfaceLib glue
  8.                 code such that a call to ADBOp under CFM68K results in a bus error.
  9.                 This bug was identified with MacOS 8.1 running on different 68040 CPU's
  10.  
  11.     Author:        RK
  12.  
  13.     Copyright:     Copyright: © 1998-1999 by Apple Computer, Inc.
  14.                 all rights reserved.
  15.     
  16.     Disclaimer:    You may incorporate this sample code into your applications without
  17.                 restriction, though the sample code has been provided "AS IS" and the
  18.                 responsibility for its operation is 100% yours.  However, what you are
  19.                 not permitted to do is to redistribute the source as "DSC Sample Code"
  20.                 after having made changes. If you're going to re-distribute the source,
  21.                 we require that you make it clear in the source that the code was
  22.                 descended from Apple Sample Code, but that you've made changes.
  23.     
  24.     Change History (most recent first):
  25.                 6/22/99    Updated for Metrowerks Codewarrior Pro 2.1(KG)
  26.                 4/7/98    Created(RK)
  27.  
  28. */
  29. #include <Types.h>
  30. #include <Events.h>
  31. #include <OSUtils.h>
  32. #include <DeskBus.h>
  33. #include <MixedMode.h>
  34.  
  35.  
  36. // keyboard ADB constants           
  37. #define kTalkCommand    8+4         
  38. #define kListenCommand  8           
  39. #define kLEDRegister    2       
  40.  
  41. #if TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  42. pascal long    GetA2( void )    ONEWORDINLINE(0x2E8A);
  43. #endif     //  TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  44.  
  45. static long             gCompletionFlag;
  46. static ADBServiceRoutineUPP completionProc;                    
  47. static pascal void CompADBOp(void);
  48.  
  49. pascal OSErr MyADBOp(Ptr refCon, ADBServiceRoutineUPP compRout, 
  50.                             Ptr buffer, short commandNum);
  51.  
  52. // example completion routine for use with ADBOp
  53. pascal void CompADBOp(void)
  54. { 
  55. #if TARGET_CPU_PPC || TARGET_RT_MAC_CFM
  56.     // Under, we can access global variables which is simpler
  57.     // than trying to write the glue code required so that 
  58.     // the completion routine is called with the registers
  59.     // set as per Inside Mac V-368
  60.     // set flag to indicate completion routine has completed
  61.     gCompletionFlag = 1;
  62. #else  // TARGET_CPU_PPC || TARGET_RT_MAC_CFM
  63.  
  64.     // under 68K, but not CFM-68K, all of the arguments are passed
  65.     // in registers so we use inline functions to access those
  66.     // arguments.  In this sample, the optional data
  67.     // buffer argument is interest since we want to set a boolean flag to 
  68.     // indicate that the completion routine has been executed.  A similar
  69.     // macro as that for GetA2 can be written to access the command buffer
  70.     // pointer in register A0
  71.     long     *completionFlagPtr;
  72.  
  73.     // set flag to indicate completion routine has run; A2 points to the flag
  74.     completionFlagPtr = (long*)GetA2(); 
  75.     *completionFlagPtr = 1;
  76. #endif  // TARGET_CPU_PPC || TARGET_RT_MAC_CFM
  77. } /* end of CompADBOp */
  78.  
  79. #if TARGET_CPU_68K && TARGET_RT_MAC_CFM
  80. // The following code is implemented to fix a bug that exists with the 
  81. // 68K InterfaceLib glue code.  In order for the glue code to work, 
  82. // a pointer to an ADBOpBlock structure must be passed in register A0.
  83. // We define the global ADBOpBlock structure to support
  84. // the asynch ADBOp call
  85.  
  86. ADBOpBlock    gADBOpBlock;
  87. #endif     //  TARGET_CPU_68K && TARGET_RT_MAC_CFM
  88.  
  89. // Instead of making the ADBOp directly, call MyADBOp which makes 
  90. // the appropriate call depending on the target architecture.
  91. // For CFM68K, the ADBOpBlock structure is filled in and the
  92. // ADBGlue routine above is called. For regular 68K and PPC, the
  93. // ADBOp call is made straightaway.
  94.  
  95. pascal OSErr MyADBOp(
  96.      Ptr refCon,
  97.      ADBServiceRoutineUPP compRout,
  98.      Ptr buffer,
  99.      short commandNum)
  100. {
  101. #if TARGET_CPU_68K && TARGET_RT_MAC_CFM
  102.     ADBOpBlock    adbOpBlock;
  103.  
  104.     adbOpBlock.dataBuffPtr = buffer;
  105.     adbOpBlock.opServiceRtPtr = compRout;
  106.     adbOpBlock.opDataAreaPtr = refCon;
  107.     
  108.     // Important Note: In this sample, we declare the adbOpBlock
  109.     // structure as a stack variable.  Normally it is bad practice
  110.     // to use a stack parameter for any asynchronous call.
  111.     // ADBOp makes a copy of the contents of the structure so the
  112.     // structure does not need to exist for the life of the 
  113.     // asynchronous call.
  114.  
  115.     // Note that the refCon value is placed into the ADBOpBlock
  116.     // structure for completeness.
  117.     // This program sample assumes that a completion routine, under
  118.     // CFM, will access the refCon and the data buffer as globals
  119.     // to the process, since under CFM, this is possible.
  120.     // Otherwise, more glue code is required so that when CFM calls
  121.     // the completion routine, the 68K registers will be set as
  122.     // per Inside Mac V-368.
  123.     
  124.     return (OSErr) CallUniversalProc((UniversalProcPtr)NGetTrapAddress(0xA07C, 0),
  125.             kRegisterBased |
  126.             RESULT_SIZE(SIZE_CODE(sizeof(OSErr))) |
  127.             REGISTER_RESULT_LOCATION(kRegisterD0) |
  128.             REGISTER_ROUTINE_PARAMETER(1,
  129.                 kRegisterA0, SIZE_CODE(sizeof(&gADBOpBlock))) |
  130.             REGISTER_ROUTINE_PARAMETER(2,
  131.                 kRegisterD0, SIZE_CODE(sizeof(commandNum))),
  132.             &gADBOpBlock,
  133.             commandNum);
  134. #else  // TARGET_CPU_68K && TARGET_RT_MAC_CFM
  135.      return (ADBOp(refCon, compRout, buffer, commandNum));
  136. #endif  // TARGET_CPU_68K && TARGET_RT_MAC_CFM
  137. }
  138.  
  139. // set the leds to the given pattern }
  140. static void kb_SetMacNumLockLED( Boolean ledOn )
  141. {
  142.     OSErr               retCode;
  143.     ADBAddress          anADBadd;       // address of each device
  144.     Byte                regBuff[9];     // buffer for ADBOp commands
  145.     Byte                oldReg;
  146.     Byte                LEDPattern;
  147.     
  148.     if ( ledOn )
  149.         LEDPattern = 0x07;
  150.     else
  151.         LEDPattern = 0x00;
  152.     
  153.     // get an address for an ADB device - here we just talk to whatever keyboard
  154.     // is at ADB Address 2.  A more complete program might check the type of
  155.     // keyboard present to ensure that it has an LED present.
  156.     anADBadd = 2;
  157.     
  158.     regBuff[0] = (Byte)0; // initial data buffer length
  159.     regBuff[1] = 0;
  160.     regBuff[2] = 0;
  161.  
  162.     // initialize the completion flag so that we will know when the ADBOp call
  163.     // has completed.
  164.     gCompletionFlag = 0;
  165.     
  166.     retCode = MyADBOp( (Ptr)&gCompletionFlag, completionProc, (Ptr)®Buff,
  167.                                 kTalkCommand + kLEDRegister + 16 * anADBadd );
  168.     
  169.     if ( retCode != noErr )         // queue was full, try again
  170.     {
  171.         gCompletionFlag = 0;
  172.         retCode = MyADBOp( (Ptr)&gCompletionFlag, completionProc, (Ptr)®Buff,
  173.                                     kTalkCommand + kLEDRegister + 16 * anADBadd );
  174.         
  175.         if ( retCode != noErr )         // queue was still full, give up
  176.             return;
  177.     }
  178.     
  179.     // do nothing until completion routine has run
  180.     do
  181.     {
  182.     }
  183.     while ( ! gCompletionFlag );
  184.             
  185.     regBuff[0] = (Byte)2; // initial data buffer length
  186.     // extended keyboard has a word of data, LEDs are low 3 bits
  187.     oldReg = regBuff[2];
  188.     
  189.     // set the specified bits; note that a clear bit indicates a lit LED
  190.     // note that if LEDpattern is 7, then all three LED's will enable.
  191.     regBuff[2] = (oldReg & 255-7) | (7 - LEDPattern);
  192.  
  193.     // initialize the completion flag so that we will know when the ADBOp call
  194.     // has completed.
  195.     gCompletionFlag = 0;                        
  196.  
  197.     retCode = MyADBOp( (Ptr)&gCompletionFlag, completionProc, (Ptr)®Buff,
  198.                                 kListenCommand + kLEDRegister + 16 * anADBadd );
  199.  
  200.     if (retCode != noErr)
  201.         DebugStr("\p error on ADBOp for listen");
  202.     else
  203.     {
  204.             // do nothing until completion routine has run
  205.         do
  206.         {
  207.         }
  208.         while ( ! gCompletionFlag );
  209.     }
  210.  
  211. } /* end of kb_SetMacNumLockLED */
  212.  
  213.  
  214. void main (void)
  215. {
  216.     unsigned long    dummy;
  217.     short    i;
  218.  
  219.     completionProc = NewADBServiceRoutineProc( CompADBOp );
  220.  
  221.     i = 0;
  222.         // press the button to quit the test
  223.     while (!Button())
  224.     {
  225.         i++;
  226.         kb_SetMacNumLockLED(i % 2);
  227.         Delay(15, &dummy);
  228.     }
  229.  
  230.     if (completionProc != nil)
  231.         DisposeRoutineDescriptor( completionProc );
  232. }
  233.